//
// "$Id: Fl_Bitmap.cxx 10132 2014-04-28 09:17:12Z manolo $"
//
// Bitmap drawing routines for the Fast Light Tool Kit (FLTK).
//
// Copyright 1998-2010 by Bill Spitzak and others.
//
// This library is free software. Distribution and use rights are outlined in
// the file "COPYING" which should have been included with this file.  If this
// file is missing or damaged, see the license at:
//
//     http://www.fltk.org/COPYING.php
//
// Please report all bugs and problems on the following page:
//
//     http://www.fltk.org/str.php
//

/** \fn Fl_Bitmap::Fl_Bitmap(const char *array, int W, int H)
  The constructors create a new bitmap from the specified bitmap data.*/

/** \fn Fl_Bitmap::Fl_Bitmap(const unsigned char *array, int W, int H)
  The constructors create a new bitmap from the specified bitmap data.*/

#include "Fl.H"
#include "x.H"
#include "fl_draw.H"
#include "Fl_Widget.H"
#include "Fl_Menu_Item.H"
#include "Fl_Bitmap.H"
#include "Fl_Printer.H"
#include "flstring.h"

#if __FLTK_WIN32__
// 'fl_create_bitmap()' - Create a 1-bit bitmap for drawing...
static Fl_Bitmask fl_create_bitmap(int w, int h, const uchar *data)
{
	// we need to pad the lines out to words & swap the bits
	// in each byte.
	int w1 = (w+7)/8;
	int w2 = ((w+15)/16)*2;
	uchar* newarray = new uchar[w2*h];
	const uchar* src = data;
	uchar* dest = newarray;
	Fl_Bitmask bm;
	static uchar reverse[16] =	/* Bit reversal lookup table */
	{
		0x00, 0x88, 0x44, 0xcc, 0x22, 0xaa, 0x66, 0xee,
		0x11, 0x99, 0x55, 0xdd, 0x33, 0xbb, 0x77, 0xff
	};

	for (int y=0; y < h; y++) {
		for (int n = 0; n < w1; n++, src++)
			*dest++ = (uchar)((reverse[*src & 0x0f] & 0xf0) |
			(reverse[(*src >> 4) & 0x0f] & 0x0f));
		dest += w2-w1;
	}

	bm = CreateBitmap(w, h, 1, 1, newarray);

	delete[] newarray;

	return bm;
}

// 'fl_create_bitmask()' - Create an N-bit bitmap for masking...
Fl_Bitmask fl_create_bitmask(int w, int h, const uchar *data)
{
	// this won't work when the user changes display mode during run or
	// has two screens with differnet depths
	Fl_Bitmask bm;
	static uchar hiNibble[16] = {
		0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0,
		0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0
	};
	static uchar loNibble[16] = {
		0x00, 0x08, 0x04, 0x0c, 0x02, 0x0a, 0x06, 0x0e,
		0x01, 0x09, 0x05, 0x0d, 0x03, 0x0b, 0x07, 0x0f
	};
	int np  = GetDeviceCaps(fl_gc, PLANES);	//: was always one on sample machines
	int bpp = GetDeviceCaps(fl_gc, BITSPIXEL);//: 1,4,8,16,24,32 and more odd stuff?
	int Bpr = (bpp*w+7)/8;			//: bytes per row
	int pad = Bpr&1, w1 = (w+7)/8, shr = ((w-1)&7)+1;
	if (bpp==4) shr = (shr+1)/2;
	uchar *newarray = new uchar[(Bpr+pad)*h];
	uchar *dst = newarray;
	const uchar *src = data;

	for (int i=0; i<h; i++) {
		// This is slooow, but we do it only once per pixmap
		for (int j=w1; j>0; j--) {
			uchar b = *src++;
			if (bpp==1) {
				*dst++ = (uchar)( hiNibble[b&15] ) | ( loNibble[(b>>4)&15] );
			} else if (bpp==4) {
				for (int k=(j==1)?shr:4; k>0; k--) {
					*dst++ = (uchar)("\377\360\017\000"[b&3]);
					b = b >> 2;
				}
			} else {
				for (int k=(j==1)?shr:8; k>0; k--) {
					if (b&1) {
						*dst++=0;
						if (bpp>8) *dst++=0;
						if (bpp>16) *dst++=0;
						if (bpp>24) *dst++=0;
					} else {
						*dst++=0xff;
						if (bpp>8) *dst++=0xff;
						if (bpp>16) *dst++=0xff;
						if (bpp>24) *dst++=0xff;
					}

					b = b >> 1;
				}
			}
		}

		dst += pad;
	}

	bm = CreateBitmap(w, h, np, bpp, newarray);
	delete[] newarray;

	return bm;
}


void fl_delete_bitmask(Fl_Bitmask bm)
{
	DeleteObject((HGDIOBJ)bm);
}
#elif __FLTK_WINCE__
// 'fl_create_bitmap()' - Create a 1-bit bitmap for drawing...
static Fl_Bitmask fl_create_bitmap(int w, int h, const uchar *data)
{
	// we need to pad the lines out to words & swap the bits
	// in each byte.
	int w1 = (w+7)/8;
	int w2 = ((w+15)/16)*2;
	uchar* newarray = new uchar[w2*h];
	const uchar* src = data;
	uchar* dest = newarray;
	Fl_Bitmask bm;
	static uchar reverse[16] =	/* Bit reversal lookup table */
	{
		0x00, 0x88, 0x44, 0xcc, 0x22, 0xaa, 0x66, 0xee,
		0x11, 0x99, 0x55, 0xdd, 0x33, 0xbb, 0x77, 0xff
	};

	for (int y=0; y < h; y++) {
		for (int n = 0; n < w1; n++, src++)
			*dest++ = (uchar)((reverse[*src & 0x0f] & 0xf0) |
			(reverse[(*src >> 4) & 0x0f] & 0x0f));
		dest += w2-w1;
	}

	bm = CreateBitmap(w, h, 1, 1, newarray);

	delete[] newarray;

	return bm;
}

// 'fl_create_bitmask()' - Create an N-bit bitmap for masking...
Fl_Bitmask fl_create_bitmask(int w, int h, const uchar *data)
{
	// this won't work when the user changes display mode during run or
	// has two screens with differnet depths
	Fl_Bitmask bm;
	static uchar hiNibble[16] = {
		0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0,
		0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0
	};
	static uchar loNibble[16] = {
		0x00, 0x08, 0x04, 0x0c, 0x02, 0x0a, 0x06, 0x0e,
		0x01, 0x09, 0x05, 0x0d, 0x03, 0x0b, 0x07, 0x0f
	};
	int np  = GetDeviceCaps(fl_gc, PLANES);	//: was always one on sample machines
	int bpp = GetDeviceCaps(fl_gc, BITSPIXEL);//: 1,4,8,16,24,32 and more odd stuff?
	int Bpr = (bpp*w+7)/8;			//: bytes per row
	int pad = Bpr&1, w1 = (w+7)/8, shr = ((w-1)&7)+1;
	if (bpp==4) shr = (shr+1)/2;
	uchar *newarray = new uchar[(Bpr+pad)*h];
	uchar *dst = newarray;
	const uchar *src = data;

	for (int i=0; i<h; i++) {
		// This is slooow, but we do it only once per pixmap
		for (int j=w1; j>0; j--) {
			uchar b = *src++;
			if (bpp==1) {
				*dst++ = (uchar)( hiNibble[b&15] ) | ( loNibble[(b>>4)&15] );
			} else if (bpp==4) {
				for (int k=(j==1)?shr:4; k>0; k--) {
					*dst++ = (uchar)("\377\360\017\000"[b&3]);
					b = b >> 2;
				}
			} else {
				for (int k=(j==1)?shr:8; k>0; k--) {
					if (b&1) {
						*dst++=0;
						if (bpp>8) *dst++=0;
						if (bpp>16) *dst++=0;
						if (bpp>24) *dst++=0;
					} else {
						*dst++=0xff;
						if (bpp>8) *dst++=0xff;
						if (bpp>16) *dst++=0xff;
						if (bpp>24) *dst++=0xff;
					}

					b = b >> 1;
				}
			}
		}

		dst += pad;
	}

	bm = CreateBitmap(w, h, np, bpp, newarray);
	delete[] newarray;

	return bm;
}


void fl_delete_bitmask(Fl_Bitmask bm)
{
	DeleteObject((HGDIOBJ)bm);
}
#elif __FLTK_MACOSX__
#if defined(__APPLE_QUARTZ__)
Fl_Bitmask fl_create_bitmask(int w, int h, const uchar *array)
{
	static uchar reverse[16] =    /* Bit reversal lookup table */
	{
		0x00, 0x88, 0x44, 0xcc, 0x22, 0xaa, 0x66, 0xee,
		0x11, 0x99, 0x55, 0xdd, 0x33, 0xbb, 0x77, 0xff
	};
	int rowBytes = (w+7)>>3 ;
	uchar *bmask = (uchar*)malloc(rowBytes*h), *dst = bmask;
	const uchar *src = array;
	for ( int i=rowBytes*h; i>0; i--,src++ ) {
		*dst++ = ((reverse[*src & 0x0f] & 0xf0) | (reverse[(*src >> 4) & 0x0f] & 0x0f))^0xff;
	}
	CGDataProviderRef srcp = CGDataProviderCreateWithData( 0L, bmask, rowBytes*h, 0L);
	CGImageRef id_ = CGImageMaskCreate( w, h, 1, 1, rowBytes, srcp, 0L, false);
	CGDataProviderRelease(srcp);
	return (Fl_Bitmask)id_;
}
void fl_delete_bitmask(Fl_Bitmask bm)
{
	if (bm) CGImageRelease((CGImageRef)bm);
}
#endif
#elif __FLTK_IPHONEOS__
Fl_Bitmask fl_create_bitmask(int w, int h, const uchar *array)
{
	static uchar reverse[16] =    /* Bit reversal lookup table */
	{
		0x00, 0x88, 0x44, 0xcc, 0x22, 0xaa, 0x66, 0xee,
		0x11, 0x99, 0x55, 0xdd, 0x33, 0xbb, 0x77, 0xff
	};
	int rowBytes = (w+7)>>3 ;
	uchar *bmask = (uchar*)malloc(rowBytes*h), *dst = bmask;
	const uchar *src = array;
	for ( int i=rowBytes*h; i>0; i--,src++ ) {
		*dst++ = ((reverse[*src & 0x0f] & 0xf0) | (reverse[(*src >> 4) & 0x0f] & 0x0f))^0xff;
	}
	CGDataProviderRef srcp = CGDataProviderCreateWithData( 0L, bmask, rowBytes*h, 0L);
	CGImageRef id_ = CGImageMaskCreate( w, h, 1, 1, rowBytes, srcp, 0L, false);
	CGDataProviderRelease(srcp);
	return (Fl_Bitmask)id_;
}
void fl_delete_bitmask(Fl_Bitmask bm)
{
	if (bm) CGImageRelease((CGImageRef)bm);
}
#elif __FLTK_LINUX__
Fl_Bitmask fl_create_bitmask(int w, int h, const uchar *data)
{
	return XCreateBitmapFromData(fl_display, fl_window, (const char *)data,
		(w+7)&-8, h);
}

void fl_delete_bitmask(Fl_Bitmask bm)
{
	fl_delete_offscreen((Fl_Offscreen)bm);
}
#elif __FLTK_S60v32__
// TODO: S60
Fl_Bitmask fl_create_bitmask(int w, int h, const uchar *data)
{
	// TODO: S60
}

void fl_delete_bitmask(Fl_Bitmask bm)
{
	fl_delete_offscreen((Fl_Offscreen)bm);
}

#elif __FLTK_ANDROID__
Fl_Bitmask fl_create_bitmask(int w, int h, const uchar *data)
{
	// TODO: S60
}

void fl_delete_bitmask(Fl_Bitmask bm)
{
	//fl_delete_offscreen((Fl_Offscreen)bm);
}

#else
#error unsupported platform
#endif

// Create a 1-bit mask used for alpha blending
Fl_Bitmask fl_create_alphamask(int w, int h, int d, int ld, const uchar *array)
{
	Fl_Bitmask bm;
	int bmw = (w + 7) / 8;
	uchar *bitmap = new uchar[bmw * h];
	uchar *bitptr, bit;
	const uchar *dataptr;
	int x, y;
	static uchar dither[16][16] = { // Simple 16x16 Floyd dither
		{
			0,   128, 32,  160, 8,   136, 40,  168,
			2,   130, 34,  162, 10,  138, 42,  170
		},
		{
			192, 64,  224, 96,  200, 72,  232, 104,
			194, 66,  226, 98,  202, 74,  234, 106
		},
		{
			48,  176, 16,  144, 56,  184, 24,  152,
			50,  178, 18,  146, 58,  186, 26,  154
		},
		{
			240, 112, 208, 80,  248, 120, 216, 88,
			242, 114, 210, 82,  250, 122, 218, 90
		},
		{
			12,  140, 44,  172, 4,   132, 36,  164,
			14,  142, 46,  174, 6,   134, 38,  166
		},
		{
			204, 76,  236, 108, 196, 68,  228, 100,
			206, 78,  238, 110, 198, 70,  230, 102
		},
		{
			60,  188, 28,  156, 52,  180, 20,  148,
			62,  190, 30,  158, 54,  182, 22,  150
		},
		{
			252, 124, 220, 92,  244, 116, 212, 84,
			254, 126, 222, 94,  246, 118, 214, 86
		},
		{
			3,   131, 35,  163, 11,  139, 43,  171,
			1,   129, 33,  161, 9,   137, 41,  169
		},
		{
			195, 67,  227, 99,  203, 75,  235, 107,
			193, 65,  225, 97,  201, 73,  233, 105
		},
		{
			51,  179, 19,  147, 59,  187, 27,  155,
			49,  177, 17,  145, 57,  185, 25,  153
		},
		{
			243, 115, 211, 83,  251, 123, 219, 91,
			241, 113, 209, 81,  249, 121, 217, 89
		},
		{
			15,  143, 47,  175, 7,   135, 39,  167,
			13,  141, 45,  173, 5,   133, 37,  165
		},
		{
			207, 79,  239, 111, 199, 71,  231, 103,
			205, 77,  237, 109, 197, 69,  229, 101
		},
		{
			63,  191, 31,  159, 55,  183, 23,  151,
			61,  189, 29,  157, 53,  181, 21,  149
		},
		{
			254, 127, 223, 95,  247, 119, 215, 87,
			253, 125, 221, 93,  245, 117, 213, 85
		}
	};

	// Generate a 1-bit "screen door" alpha mask; not always pretty, but
	// definitely fast...  In the future we may be able to support things
	// like the RENDER extension in XFree86, when available, to provide
	// true RGBA-blended rendering.  See:
	//
	//     http://www.xfree86.org/~keithp/render/protocol.html
	//
	// for more info on XRender...
	//
	// MacOS already provides alpha blending support and has its own
	// fl_create_alphamask() function...
	memset(bitmap, 0, bmw * h);

	for (dataptr = array + d - 1, y = 0; y < h; y ++, dataptr += ld)
		for (bitptr = bitmap + y * bmw, bit = 1, x = 0; x < w; x ++, dataptr += d) {
			if (*dataptr > dither[x & 15][y & 15])
				*bitptr |= bit;
			if (bit < 128) bit <<= 1;
			else {
				bit = 1;
				bitptr ++;
			}
		}

	bm = fl_create_bitmask(w, h, bitmap);
	delete[] bitmap;

	return (bm);
}

void Fl_Bitmap::draw(int XP, int YP, int WP, int HP, int cx, int cy)
{
	fl_graphics_driver->draw(this, XP, YP, WP, HP, cx, cy);
}

int Fl_Bitmap::start(int XP, int YP, int WP, int HP, int &cx, int &cy,
                     int &X, int &Y, int &W, int &H)
{
	if (!array) {
		draw_empty(XP, YP);
		return 1;
	}
	// account for current clip region (faster on Irix):
	fl_clip_box(XP,YP,WP,HP,X,Y,W,H);
	cx += X-XP;
	cy += Y-YP;
	// clip the box down to the size of image, quit if empty:
	if (cx < 0) {
		W += cx;
		X -= cx;
		cx = 0;
	}
	if (cx+W > w()) W = w()-cx;
	if (W <= 0) return 1;
	if (cy < 0) {
		H += cy;
		Y -= cy;
		cy = 0;
	}
	if (cy+H > h()) H = h()-cy;
	if (H <= 0) return 1;
#if __FLTK_WIN32__
	if (!id_) id_ = fl_create_bitmap(w(), h(), array);
#elif __FLTK_ANDROID__
	//if (!id_) id_ = fl_create_bitmap(w(), h(), array);
#else
	if (!id_) id_ = fl_create_bitmask(w(), h(), array);
#endif
	return 0;
}

#if __FLTK_WIN32__
void Fl_GDI_Graphics_Driver::draw(Fl_Bitmap *bm, int XP, int YP, int WP, int HP, int cx, int cy)
{
	int X, Y, W, H;
	if (bm->start(XP, YP, WP, HP, cx, cy, X, Y, W, H)) {
		return;
	}

	HDC tempdc = CreateCompatibleDC(fl_gc);
	int save = SaveDC(tempdc);
	SelectObject(tempdc, (HGDIOBJ)bm->id_);
	SelectObject(fl_gc, fl_brush());
	// secret bitblt code found in old MSWindows reference manual:
	BitBlt(fl_gc, X, Y, W, H, tempdc, cx, cy, 0xE20746L);
	RestoreDC(tempdc, save);
	DeleteDC(tempdc);
}

void Fl_GDI_Printer_Graphics_Driver::draw(Fl_Bitmap *bm, int XP, int YP, int WP, int HP, int cx, int cy)
{
	int X, Y, W, H;
	typedef BOOL (WINAPI* fl_transp_func)  (HDC,int,int,int,int,HDC,int,int,int,int,UINT);
	static fl_transp_func fl_TransparentBlt = NULL;
	static HMODULE hMod = NULL;
	if (!hMod) {
		hMod = LoadLibraryA("MSIMG32.DLL");
		if (hMod) fl_TransparentBlt = (fl_transp_func)GetProcAddress(hMod, "TransparentBlt");
	}
	if (!fl_TransparentBlt) {
		Fl_GDI_Graphics_Driver::draw(bm,  XP,  YP,  WP,  HP,  cx,  cy);
		return;
	}
	if (bm->start(XP, YP, WP, HP, cx, cy, X, Y, W, H)) {
		return;
	}

	HDC tempdc;
	int save;
	// algorithm for bitmap output to Fl_GDI_Printer
	Fl_Color save_c = fl_color(); // save bitmap's desired color
	uchar r, g, b;
	Fl::get_color(save_c, r, g, b);
	r = 255-r;
	g = 255-g;
	b = 255-b;
	Fl_Color background = fl_rgb_color(r, g, b); // a color very different from the bitmap's
	Fl_Offscreen tmp_id = fl_create_offscreen(W, H);
	fl_begin_offscreen(tmp_id);
	fl_color(background);
	fl_rectf(0,0,W,H); // use this color as offscreen background
	fl_color(save_c); // back to bitmap's color
	tempdc = CreateCompatibleDC(fl_gc);
	save = SaveDC(tempdc);
	SelectObject(tempdc, (HGDIOBJ)bm->id_);
	SelectObject(fl_gc, fl_brush()); // use bitmap's desired color
	BitBlt(fl_gc, 0, 0, W, H, tempdc, 0, 0, 0xE20746L); // draw bitmap to offscreen
	fl_end_offscreen(); // offscreen data is in tmp_id
	SelectObject(tempdc, (HGDIOBJ)tmp_id); // use offscreen data
	// draw it to printer context with background color as transparent
	fl_TransparentBlt(fl_gc, X,Y,W,H, tempdc, cx, cy, bm->w(), bm->h(), RGB(r, g, b) );
	fl_delete_offscreen(tmp_id);
	RestoreDC(tempdc, save);
	DeleteDC(tempdc);
}
#elif __FLTK_WINCE__
void Fl_GDI_Graphics_Driver::draw(Fl_Bitmap *bm, int XP, int YP, int WP, int HP, int cx, int cy)
{
	int X, Y, W, H;
	if (bm->start(XP, YP, WP, HP, cx, cy, X, Y, W, H)) {
		return;
	}

	HDC tempdc = CreateCompatibleDC(fl_gc);
	int save = SaveDC(tempdc);
	SelectObject(tempdc, (HGDIOBJ)bm->id_);
	SelectObject(fl_gc, fl_brush());
	// secret bitblt code found in old MSWindows reference manual:
	BitBlt(fl_gc, X, Y, W, H, tempdc, cx, cy, 0xE20746L);
	RestoreDC(tempdc, save);
	DeleteDC(tempdc);
}

void Fl_GDI_Printer_Graphics_Driver::draw(Fl_Bitmap *bm, int XP, int YP, int WP, int HP, int cx, int cy)
{
	int X, Y, W, H;
	/*
	typedef BOOL (WINAPI* fl_transp_func)  (HDC,int,int,int,int,HDC,int,int,int,int,UINT);
	static fl_transp_func fl_TransparentBlt = NULL;
	static HMODULE hMod = NULL;
	if (!hMod) {
		hMod = LoadLibraryA("MSIMG32.DLL");
		if (hMod) fl_TransparentBlt = (fl_transp_func)GetProcAddress(hMod, "TransparentBlt");
	}
	if (!fl_TransparentBlt) {
		Fl_GDI_Graphics_Driver::draw(bm,  XP,  YP,  WP,  HP,  cx,  cy);
		return;
	}
	*/
	if (bm->start(XP, YP, WP, HP, cx, cy, X, Y, W, H)) {
		return;
	}

	HDC tempdc;
	int save;
	// algorithm for bitmap output to Fl_GDI_Printer
	Fl_Color save_c = fl_color(); // save bitmap's desired color
	uchar r, g, b;
	Fl::get_color(save_c, r, g, b);
	r = 255-r;
	g = 255-g;
	b = 255-b;
	Fl_Color background = fl_rgb_color(r, g, b); // a color very different from the bitmap's
	Fl_Offscreen tmp_id = fl_create_offscreen(W, H);
	fl_begin_offscreen(tmp_id);
	fl_color(background);
	fl_rectf(0,0,W,H); // use this color as offscreen background
	fl_color(save_c); // back to bitmap's color
	tempdc = CreateCompatibleDC(fl_gc);
	save = SaveDC(tempdc);
	SelectObject(tempdc, (HGDIOBJ)bm->id_);
	SelectObject(fl_gc, fl_brush()); // use bitmap's desired color
	BitBlt(fl_gc, 0, 0, W, H, tempdc, 0, 0, 0xE20746L); // draw bitmap to offscreen
	fl_end_offscreen(); // offscreen data is in tmp_id
	SelectObject(tempdc, (HGDIOBJ)tmp_id); // use offscreen data
	// draw it to printer context with background color as transparent
	TransparentBlt(fl_gc, X,Y,W,H, tempdc, cx, cy, bm->w(), bm->h(), RGB(r, g, b) );
	fl_delete_offscreen(tmp_id);
	RestoreDC(tempdc, save);
	DeleteDC(tempdc);
}
#elif __FLTK_MACOSX__
void Fl_Quartz_Graphics_Driver::draw(Fl_Bitmap *bm, int XP, int YP, int WP, int HP, int cx, int cy)
{
	int X, Y, W, H;
	if (bm->start(XP, YP, WP, HP, cx, cy, X, Y, W, H)) {
		return;
	}
	if (bm->id_ && fl_gc) {
		CGRect rect = { { (CGFloat)X, (CGFloat)Y }, { (CGFloat)W, (CGFloat)H } };
		Fl_X::q_begin_image(rect, cx, cy, bm->w(), bm->h());
		CGContextDrawImage(fl_gc, rect, (CGImageRef)bm->id_);
		Fl_X::q_end_image();
	}
}
#elif __FLTK_IPHONEOS__
void Fl_Quartz_Graphics_Driver::draw(Fl_Bitmap *bm, int XP, int YP, int WP, int HP, int cx, int cy)
{
	int X, Y, W, H;
	if (bm->start(XP, YP, WP, HP, cx, cy, X, Y, W, H)) {
		return;
	}
	if (bm->id_ && fl_gc) {
		CGRect rect = { { (CGFloat)X, (CGFloat)Y }, { (CGFloat)W, (CGFloat)H } };
		Fl_X::q_begin_image(rect, cx, cy, bm->w(), bm->h());
		CGContextDrawImage(fl_gc, rect, (CGImageRef)bm->id_);
		Fl_X::q_end_image();
	}
}
#elif __FLTK_LINUX__
void Fl_Xlib_Graphics_Driver::draw(Fl_Bitmap *bm, int XP, int YP, int WP, int HP, int cx, int cy)
{
	int X, Y, W, H;
	if (bm->start(XP, YP, WP, HP, cx, cy, X, Y, W, H)) {
		return;
	}

	XSetStipple(fl_display, fl_gc, bm->id_);
	int ox = X-cx;
	if (ox < 0) ox += bm->w();
	int oy = Y-cy;
	if (oy < 0) oy += bm->h();
	XSetTSOrigin(fl_display, fl_gc, ox, oy);
	XSetFillStyle(fl_display, fl_gc, FillStippled);
	XFillRectangle(fl_display, fl_window, fl_gc, X, Y, W, H);
	XSetFillStyle(fl_display, fl_gc, FillSolid);
}
#elif __FLTK_S60v32__
	// TODO: S60
#elif __FLTK_ANDROID__
#else
#error unsupported platform
#endif

/**
  The destructor free all memory and server resources that are used by
  the bitmap.
*/
Fl_Bitmap::~Fl_Bitmap()
{
	uncache();
	if (alloc_array) delete[] (uchar *)array;
}

void Fl_Bitmap::uncache()
{
	if (id_) {
#if __FLTK_MACOSX__	
		fl_delete_bitmask((Fl_Bitmask)id_);
#elif __FLTK_IPHONEOS__		
		fl_delete_bitmask((Fl_Bitmask)id_);
#else
		fl_delete_bitmask((Fl_Offscreen)id_);
#endif
		id_ = 0;
	}
}

void Fl_Bitmap::label(Fl_Widget* widget)
{
	widget->image(this);
}

void Fl_Bitmap::label(Fl_Menu_Item* m)
{
	Fl::set_labeltype(_FL_IMAGE_LABEL, labeltype, measure);
	m->label(_FL_IMAGE_LABEL, (const char*)this);
}

Fl_Image *Fl_Bitmap::copy(int W, int H)
{
	Fl_Bitmap	*new_image;	// New RGB image
	uchar		*new_array;	// New array for image data

	// Optimize the simple copy where the width and height are the same...
	if (W == w() && H == h()) {
		new_array = new uchar [H * ((W + 7) / 8)];
		memcpy(new_array, array, H * ((W + 7) / 8));

		new_image = new Fl_Bitmap(new_array, W, H);
		new_image->alloc_array = 1;

		return new_image;
	}
	if (W <= 0 || H <= 0) return 0;

	// OK, need to resize the image data; allocate memory and
	uchar		*new_ptr,	// Pointer into new array
	new_bit,	// Bit for new array
	old_bit;	// Bit for old array
	const uchar	*old_ptr;	// Pointer into old array
	int		sx, sy,		// Source coordinates
	dx, dy,		// Destination coordinates
	xerr, yerr,	// X & Y errors
	xmod, ymod,	// X & Y moduli
	xstep, ystep;	// X & Y step increments


	// Figure out Bresenheim step/modulus values...
	xmod   = w() % W;
	xstep  = w() / W;
	ymod   = h() % H;
	ystep  = h() / H;

	// Allocate memory for the new image...
	new_array = new uchar [H * ((W + 7) / 8)];
	new_image = new Fl_Bitmap(new_array, W, H);
	new_image->alloc_array = 1;

	memset(new_array, 0, H * ((W + 7) / 8));

	// Scale the image using a nearest-neighbor algorithm...
	for (dy = H, sy = 0, yerr = H, new_ptr = new_array; dy > 0; dy --) {
		for (dx = W, xerr = W, old_ptr = array + sy * ((w() + 7) / 8), sx = 0, new_bit = 1;
		dx > 0;
		dx --) {
			old_bit = (uchar)(1 << (sx & 7));
			if (old_ptr[sx / 8] & old_bit) *new_ptr |= new_bit;

			if (new_bit < 128) new_bit <<= 1;
			else {
				new_bit = 1;
				new_ptr ++;
			}

			sx   += xstep;
			xerr -= xmod;

			if (xerr <= 0) {
				xerr += W;
				sx ++;
			}
		}

		if (new_bit > 1) new_ptr ++;

		sy   += ystep;
		yerr -= ymod;
		if (yerr <= 0) {
			yerr += H;
			sy ++;
		}
	}

	return new_image;
}


//
// End of "$Id: Fl_Bitmap.cxx 10132 2014-04-28 09:17:12Z manolo $".
//
